home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 051-075 / disk_074 / makemake / makemake.c < prev   
C/C++ Source or Header  |  1992-05-06  |  7KB  |  256 lines
  1. /*
  2.  *
  3.  * MakeMake - a program to construct a makefile from C source code
  4.  *
  5.  *   Usage: makemake file1.c file2.c file3.c ... filen.c
  6.  *
  7.  * MakeMake reads the C source files and creates
  8.  * a file called 'makefile' in the current directory. For each
  9.  * source file entered on the command line, makemake adds an entry 
  10.  * of the form:
  11.  * 
  12.  *   filex.o :    filex.c ... header file list ...
  13.  *       cc $(OPT) filex.c
  14.  * 
  15.  * where the header file list is the transitive closure of all
  16.  * files #included in filex.c (i.e. if filex.c #includes "header.h", and
  17.  * "header.h" #includes "subheader.h", both "header.h" and "subheader.h"
  18.  * appear in the list of header files). MakeMake only examines header
  19.  * files delimited by double quotes ("). System header files enclosed
  20.  * in angle brackets (< and >) are not examined.
  21.  * 
  22.  * The target of the makefile is assumed to be a program called 'main', 
  23.  * with dependencies as shown:
  24.  * 
  25.  * main :  file1.o file2.o file3.o ... filek.o
  26.  * main :  filek+1.o ... filen.o
  27.  * # ------- construction command goes here ---------
  28.  * 
  29.  * At this point, the programmer should edit the resulting makefile
  30.  * to add the statement sequence which builds the program from the 
  31.  * compiled object code by replacing the '#' comment line.
  32.  * 
  33.  * The makefile has a hook for specifying compilation options through
  34.  * symbol OPT. 
  35.  * 
  36.  * Written and placed in the public domain by Tim McGrath 4/2/87
  37.  * 
  38.  */
  39. #include <stdio.h>
  40. #define LINEMAX 80
  41. #define MAINPGM "main"
  42.  
  43. long malloc();
  44. char *strcat(),*strcpy();
  45.  
  46. FILE *makefile;
  47.  
  48. main(argc,argv)
  49.     char **argv; 
  50.     int argc;
  51. { 
  52.   int dependent_count;
  53.   char **dependents;
  54.   int i;
  55.   
  56.   if ((makefile = fopen("makefile","w")) == 0L) {
  57.     puts("Can't create makefile"); exit(1);
  58.   }
  59.   fprintf(makefile,"OPT = \n\n");
  60.   depend_file(argc,argv,MAINPGM,"  ",".o");
  61.   for (i = 1; i < argc; i++) {
  62.     get_dependents(argv[i],&dependents,&dependent_count);
  63.     depend_file(dependent_count,dependents,argv[i],".o","");
  64.     free_space(dependents,dependent_count);
  65.   }
  66.   fclose(makefile); exit(0);
  67. }
  68.  
  69. free_space(dp,dc)
  70. /* 
  71.  * Purpose: free up list of file names
  72.  * Inputs:  dp - points to list of pointers to strings
  73.  *        dc - number of pointers in the list
  74.  */
  75.     char **dp;
  76.     int dc;
  77. {
  78.   while (dc > 0) {
  79.     free(*dp++); dc--;
  80.   }
  81.   free(dp);
  82. }
  83.  
  84. char *
  85. file_exten(pgm_name,xtension,bufout)
  86. /* 
  87.  * Purpose: append new extension onto file name 
  88.  * Inputs:  pgm_name - pointer to name of file
  89.  *        xtension - pointer to new file name extension (2 chars only)
  90.  * Outputs: bufout - points to area for new file name
  91.  * Returns: bufout
  92.  */
  93.      char *pgm_name,*xtension,*bufout;
  94. {
  95.   int i = 0;
  96.   
  97.   while (*pgm_name) {
  98.     bufout[i++] = *pgm_name;
  99.     if (*pgm_name++ == '.' && xtension[0] != '\0') {
  100.       bufout[i++] = xtension[1]; 
  101.       break;
  102.     }
  103.   }
  104.   bufout[i] = '\0'; return(bufout);
  105. }
  106.  
  107. depend_file(ct,flist,pgm_name,pgmx,filex)
  108. /* 
  109.  * Purpose: print file name and list of dependents
  110.  * Inputs:  ct - number of dependents in the list
  111.  *        flist - pointer to a list of pointers to dependent names
  112.  *        pgm_name - name of file whose dependents are being printed
  113.  *        pgmx - extension for pgm_name file (or "" if none)
  114.  *        filex - extension for dependent file names (or "" if none)
  115.  */
  116.     char **flist,*pgm_name,*pgmx,*filex;
  117.     int ct;
  118. {
  119.   int i;
  120.   char buf[LINEMAX], add_name[LINEMAX], pname[LINEMAX];
  121.   
  122.   start_line(file_exten(pgm_name,pgmx,pname),buf);
  123.   if (strcmp(pgm_name,MAINPGM)) strcat(strcat(buf," "),pgm_name);
  124.   for (i = 1; i < ct; i++) {
  125.     file_exten(flist[i],filex,add_name);
  126.     if (columns(buf)+strlen(add_name)+1 >= LINEMAX - 1) {
  127.       fputs(buf,makefile); fputc('\n',makefile);
  128.       start_line(file_exten(pgm_name,pgmx,pname),buf);
  129.     }
  130.     strcat(strcat(buf," "),add_name);
  131.   }
  132.   fputs(buf,makefile); fputc('\n',makefile);
  133.   if (strcmp(pgm_name,MAINPGM)) fprintf(makefile,"\tcc $(OPT) %s\n",pgm_name);
  134.   else { 
  135.     fputs("# ------- construction command goes here ---------",makefile);
  136.     fputc('\n',makefile);
  137.   }
  138. }
  139.  
  140.  
  141. start_line(with_name,buf)
  142. /* 
  143.  * Purpose: give each line a standard indentation 
  144.  * Inputs:  with_name - name of root file on each line
  145.  *        buf - place to put indented line
  146.  */
  147.     char *with_name,*buf;
  148. {
  149.   strcpy(buf,with_name); strcat(buf,"\t");
  150.   if (columns(buf) < 16) strcat(buf,"\t");
  151.   if (columns(buf) < 24) strcat(buf,"\t");
  152.   strcat(buf,":");
  153. }
  154.  
  155. columns(s)
  156. /* 
  157.  * Purpose: count the number of columns a line spans
  158.  * Inputs:  s - the characters in a line
  159.  * Returns: the number of columns (including tab expansion)
  160.  */
  161.     char *s;
  162. {
  163.   int col = 0;
  164.   
  165.   while (*s) {
  166.     if (*s++ == '\t') while (++col & 7);
  167.     else ++col;
  168.   }
  169.   return(col);
  170. }
  171.  
  172. get_dependents(fn,depv,depc)
  173. /* 
  174.  * Purpose: return a list of files depending on a C source file
  175.  * Inputs:  fn - name of the c source file
  176.  * Outputs: depv - list of dependents (an array of pointers to filenames)
  177.  *        depc - number of dependents
  178.  */
  179.      char *fn,***depv;
  180.      int *depc;
  181. {
  182.   char **lst;
  183.   int i;
  184.  
  185.   lst = (char **) malloc(1024*sizeof(char *)); move_name(&lst[0],fn);
  186.   fputs(fn,stdout); fputc('\n',stdout); i = 0;
  187.   
  188.   scan_file(lst,&i,fn); *depv = lst; *depc = i+1;
  189. }
  190.  
  191. move_name(p,s)
  192. /* 
  193.  * Purpose: Allocate space for a new filename and copy it
  194.  * Inputs:  p - location for new pointer to filename
  195.  *        s - pointer to file name
  196.  */
  197.      char **p,*s;
  198. {
  199.   *p = (char *) malloc(strlen(s)+1); strcpy(*p,s);
  200. }
  201.  
  202. scan_file(file_name_list,last_list_used,fn)
  203. /* 
  204.  * Purpose: search a C source file file #includes, and search the #includes
  205.  *        for nested #includes 
  206.  * Inputs:  fn - name of file to scan
  207.  * Outputs: file_name_list - list of included files 
  208.  *        last_list_used - last used filename position in file_name_list
  209.  */
  210.   char **file_name_list, *fn;
  211.   int *last_list_used;
  212. {
  213.   FILE *fp,*fopen();
  214.   char buf[1024],ifn[LINEMAX];
  215.   int j,k;
  216.  
  217.   fp = fopen(fn,"r");
  218.   if (!fp) { fprintf(stdout,"Couldn't open file %s\n",fn); return; }
  219.  
  220.   while (fgets(buf,1024,fp)) {
  221.     if (strncmp(buf,"#include",8) == 0) {
  222.       j = 8;
  223.       while (buf[j] == ' ' || buf[j] == '\t') j++;
  224.       if (buf[j++] != '"') continue;
  225.       k = 0;
  226.       while (buf[j]) {
  227.         if (buf[j] == '"' || buf[j] == '\n') break;
  228.         else ifn[k++] = buf[j++];
  229.       }
  230.       ifn[k] = '\0';
  231.       if (add_name(file_name_list, last_list_used, ifn))
  232.         scan_file(file_name_list, last_list_used, ifn);
  233.     }
  234.   }
  235.   fclose(fp); return;
  236. }
  237.  
  238. add_name(file_name_list, last_list_used, fn)
  239. /* 
  240.  * Purpose: Add a file name to the list if it's not there already
  241.  * Inputs:  file_name_list - pointer to array of pointers to file names
  242.  *        last_list_used - last element in array with a filename
  243.  *        fn - name of file
  244.  * Returns: 1 if file name added, 0 otherwise
  245.  */
  246.   char **file_name_list, *fn;
  247.   int *last_list_used;
  248. {
  249.   int i;
  250.   for (i = 0; i <= *last_list_used; i++)
  251.     if (!strcmp(file_name_list[i],fn)) return(0);
  252.   *last_list_used += 1;
  253.   move_name(&file_name_list[*last_list_used],fn);
  254.   return(1);
  255. }
  256.